<?xml version="1.0"?>
<doc>
    <assembly>
        <name>PersistantModel</name>
    </assembly>
    <members>
        <member name="T:PersistantModel.Gathering`1">
            <summary>
            Class to gather all records
            into a graph of shared nodes
            </summary>
            <typeparam name="T">Persistent object</typeparam>
        </member>
        <member name="F:PersistantModel.Gathering`1.records">
            <summary>
            Records
            </summary>
        </member>
        <member name="F:PersistantModel.Gathering`1.opened">
            <summary>
            List of terms not visited and already visited
            </summary>
        </member>
        <member name="F:PersistantModel.Gathering`1.closed">
            <summary>
            List of terms not visited and already visited
            </summary>
        </member>
        <member name="M:PersistantModel.Gathering`1.#ctor(PersistantModel.RecordZone{`0},`0)">
            <summary>
            Default constructor
            </summary>
            <param name="r">records</param>
            <param name="start">start</param>
        </member>
        <member name="T:PersistantModel.RecordZone`1">
            <summary>
            Recording zone to handle objects
            </summary>
        </member>
        <member name="F:PersistantModel.RecordZone`1.objectListName">
            <summary>
            Store objects
            </summary>
        </member>
        <member name="M:PersistantModel.RecordZone`1.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:PersistantModel.RecordZone`1.#ctor(System.Collections.Generic.KeyValuePair{System.Int32,`0}[])">
            <summary>
            Constructor
            given an existing dictionary of objects
            </summary>
            <param name="keys"></param>
        </member>
        <member name="P:PersistantModel.RecordZone`1.Records">
            <summary>
            Gets all records
            </summary>
        </member>
        <member name="M:PersistantModel.RecordZone`1.Add(System.Int32,`0)">
            <summary>
            Register a new object into records
            </summary>
            <param name="h">hash code</param>
            <param name="obj">object to register</param>
            <returns>true if registered</returns>
        </member>
        <member name="M:PersistantModel.RecordZone`1.Ask(System.Int32)">
            <summary>
            Ask to get a recorded object
            identified by a hash code
            </summary>
            <param name="hashCode">hash code</param>
            <returns>object</returns>
        </member>
        <member name="M:PersistantModel.RecordZone`1.Exists(System.Int32)">
            <summary>
            Test if a specific hash code already exists
            </summary>
            <param name="hashCode">hash code</param>
            <returns>true if already exists</returns>
        </member>
        <member name="T:PersistantModel.Texte">
            <summary>
            Classe supportant un texte
            ou un document rtf
            </summary>
        </member>
        <member name="M:PersistantModel.Texte.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Texte.#ctor(System.String)">
            <summary>
            Constructor
            given a specific text
            </summary>
            <param name="t">text</param>
        </member>
        <member name="P:PersistantModel.Texte.IsCalculable">
            <summary>
            Test if calculable
            </summary>
        </member>
        <member name="P:PersistantModel.Texte.Content">
            <summary>
            Gets or sets the content
            </summary>
        </member>
        <member name="M:PersistantModel.Texte.ToTex">
            <summary>
            Converts content to tex
            </summary>
            <returns></returns>
        </member>
        <member name="M:PersistantModel.Texte.ToString">
            <summary>
            Affiche le texte
            </summary>
            <returns>contenu du texte</returns>
        </member>
        <member name="T:PersistantModel.UnaryOperation">
            <summary>
            Définit une opération unaire
            </summary>
        </member>
        <member name="M:PersistantModel.UnaryOperation.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.UnaryOperation.#ctor(System.Char,System.Double)">
            <summary>
            Constructor
            given a unary operation with one number
            </summary>
            <param name="op">operator</param>
            <param name="n">number</param>
        </member>
        <member name="M:PersistantModel.UnaryOperation.#ctor(System.Char,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a unary operation with one term
            </summary>
            <param name="op">operator</param>
            <param name="t">term</param>
        </member>
        <member name="P:PersistantModel.UnaryOperation.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.UnaryOperation.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.UnaryOperation.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.UnaryOperation.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="P:PersistantModel.UnaryOperation.InnerOperand">
            <summary>
            Gets the left operand
            </summary>
        </member>
        <member name="M:PersistantModel.UnaryOperation.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.UnaryOperation.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.Inverse">
            <summary>
            Persistent data format of an inverse value
            </summary>
        </member>
        <member name="M:PersistantModel.Inverse.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Inverse.#ctor(System.Double)">
            <summary>
            Constructor
            given a positive value with one number
            </summary>
            <param name="n">number</param>
        </member>
        <member name="M:PersistantModel.Inverse.#ctor(Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a positive value with one term
            </summary>
            <param name="n">term</param>
        </member>
        <member name="M:PersistantModel.Inverse.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Inverse.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.Negative">
            <summary>
            Persistent data format of a negative value
            </summary>
        </member>
        <member name="M:PersistantModel.Negative.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Negative.#ctor(System.Double)">
            <summary>
            Constructor
            given a positive value with one number
            </summary>
            <param name="n">number</param>
        </member>
        <member name="M:PersistantModel.Negative.#ctor(Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a positive value with one term
            </summary>
            <param name="n">term</param>
        </member>
        <member name="P:PersistantModel.Negative.Operator">
            <summary>
            Gets the operator char
            </summary>
        </member>
        <member name="M:PersistantModel.Negative.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.BinaryOperation">
            <summary>
            Définit une opération binaire
            </summary>
        </member>
        <member name="M:PersistantModel.BinaryOperation.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.BinaryOperation.#ctor(System.Char,System.Double,System.Double)">
            <summary>
            Constructor
            given a binary operation with two numbers
            </summary>
            <param name="op">operator id</param>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.BinaryOperation.#ctor(System.Char,Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a binary operation with two terms
            </summary>
            <param name="op">operator id</param>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="P:PersistantModel.BinaryOperation.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.BinaryOperation.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.BinaryOperation.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.BinaryOperation.IsMultipleOperator">
            <summary>
            Gets multiple switch test
            </summary>
        </member>
        <member name="P:PersistantModel.BinaryOperation.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="P:PersistantModel.BinaryOperation.LeftOperand">
            <summary>
            Gets the left operand
            </summary>
        </member>
        <member name="P:PersistantModel.BinaryOperation.RightOperand">
            <summary>
            Gets the right operand
            </summary>
        </member>
        <member name="M:PersistantModel.BinaryOperation.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.BinaryOperation.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.Positive">
            <summary>
            Persistent data format of a positive value
            </summary>
        </member>
        <member name="M:PersistantModel.Positive.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Positive.#ctor(System.Double)">
            <summary>
            Constructor
            given a positive value with one number
            </summary>
            <param name="n">number</param>
        </member>
        <member name="M:PersistantModel.Positive.#ctor(Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a positive value with one term
            </summary>
            <param name="n">term</param>
        </member>
        <member name="P:PersistantModel.Positive.Operator">
            <summary>
            Gets the operator char
            </summary>
        </member>
        <member name="M:PersistantModel.Positive.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.Power">
            <summary>
            Persistent data format of a power
            </summary>
        </member>
        <member name="M:PersistantModel.Power.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Power.#ctor(System.Double,System.Double)">
            <summary>
            Default constructor
            given a n2 power of n1
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Power.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a n2 power of n1
            </summary>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="M:PersistantModel.Power.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Power.ToString">
            <summary>
            Transforms equation object into a string representation
            </summary>
            <returns>string representation</returns>
        </member>
        <member name="M:PersistantModel.Power.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Root">
            <summary>
            Persistent data format of a root
            </summary>
        </member>
        <member name="M:PersistantModel.Root.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Root.#ctor(System.Double,System.Double)">
            <summary>
            Default constructor
            given a n2 root of n1
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Root.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a n2 root of n1
            </summary>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="M:PersistantModel.Root.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Root.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Soustraction">
            <summary>
            Persistent data format of a substract
            </summary>
        </member>
        <member name="M:PersistantModel.Soustraction.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Soustraction.#ctor(System.Double,System.Double)">
            <summary>
            Constructor
            given an addition with two numbers
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Soustraction.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given an addition with two terms
            </summary>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="M:PersistantModel.Soustraction.ToSum">
            <summary>
            Convert additions to a sum
            </summary>
            <returns></returns>
        </member>
        <member name="M:PersistantModel.Soustraction.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.Equal">
            <summary>
            Equality assertion arithmetic operator
            </summary>
        </member>
        <member name="M:PersistantModel.Equal.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Equal.#ctor(System.Double,System.Double)">
            <summary>
            Constructor
            given an equality with two numbers
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Equal.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given an equality with two equations
            </summary>
            <param name="t1">left equation</param>
            <param name="t2">right equation</param>
        </member>
        <member name="M:PersistantModel.Equal.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Equal.ToString">
            <summary>
            Transforms equation object into a string representation
            </summary>
            <returns>string representation</returns>
        </member>
        <member name="M:PersistantModel.Equal.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Division">
            <summary>
            Persistent data format of a division
            </summary>
        </member>
        <member name="M:PersistantModel.Division.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Division.#ctor(System.Double,System.Double)">
            <summary>
            Default constructor
            given an addition with two numbers
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Division.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a multiplication with two terms
            </summary>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="M:PersistantModel.Division.ToProduct">
            <summary>
            Convert mult to a product
            </summary>
            <returns>product</returns>
        </member>
        <member name="M:PersistantModel.Division.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Division.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Multiplication">
            <summary>
            Persistent data format of a product
            </summary>
        </member>
        <member name="M:PersistantModel.Multiplication.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Multiplication.#ctor(System.Double,System.Double)">
            <summary>
            Default constructor
            given an addition with two numbers
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Multiplication.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a multiplication with two terms
            </summary>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="M:PersistantModel.Multiplication.MakeTransform">
            <summary>
            Transforms an addition into a multiplication
            </summary>
            <returns>a list of possibles equation</returns>
        </member>
        <member name="M:PersistantModel.Multiplication.ToProduct">
            <summary>
            Convert mult to a product
            </summary>
            <returns>product</returns>
        </member>
        <member name="M:PersistantModel.Multiplication.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Addition">
            <summary>
            Persistent data format of an addition
            </summary>
        </member>
        <member name="M:PersistantModel.Addition.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Addition.#ctor(System.Double,System.Double)">
            <summary>
            Constructor
            given an addition with two numbers
            </summary>
            <param name="n1">left number</param>
            <param name="n2">right number</param>
        </member>
        <member name="M:PersistantModel.Addition.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given an addition with two terms
            </summary>
            <param name="t1">left term</param>
            <param name="t2">right term</param>
        </member>
        <member name="M:PersistantModel.Addition.MakeTransform">
            <summary>
            Transforms an addition into a multiplication
            </summary>
            <returns>a list of possibles equation</returns>
        </member>
        <member name="M:PersistantModel.Addition.ToSum">
            <summary>
            Convert additions to a sum
            </summary>
            <returns></returns>
        </member>
        <member name="M:PersistantModel.Addition.Create">
            <summary>
            Create a new addition class
            </summary>
        </member>
        <member name="T:PersistantModel.Arithmetic">
            <summary>
            Classe permettant
            d'enregistrer des éléments
            arithmetiques
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.equationName">
            <summary>
            Index name to store the equation object
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.letterName">
            <summary>
            nom pour le champ lettre
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.hasValueName">
            <summary>
            Index name to store a boolean value of having an existing value
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.valueName">
            <summary>
            nom pour le champ valeur
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.operatorName">
            <summary>
            Index name to store operator name
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.innerOperandName">
            <summary>
            Index name to store value
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.leftTermName">
            <summary>
            Index name to store left value
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.rightTermName">
            <summary>
            Index name to store right value
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.constantName">
            <summary>
            Index name to store a constant
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.coefName">
            <summary>
            Index name to store a coefficient
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.unknownName">
            <summary>
            Index name to store an unknown term
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.isCalculableName">
            <summary>
            Boolean to act equation as calculable
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.calculatedValueName">
            <summary>
            Value that acts as a calculated result
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.uncalculatedValueName">
            <summary>
            String element that acts as an un-calculable result
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.listName">
            <summary>
            Index name to store list
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.weight">
            <summary>
            Computed weight
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.recordZone">
            <summary>
            mutualized record zone
            </summary>
        </member>
        <member name="F:PersistantModel.Arithmetic.persistentData">
            <summary>
            Inner data informations
            </summary>
        </member>
        <member name="E:PersistantModel.Arithmetic.eventFetch">
            <summary>
            Events
            </summary>
        </member>
        <member name="E:PersistantModel.Arithmetic.eventUnfetch">
            <summary>
            Events
            </summary>
        </member>
        <member name="M:PersistantModel.Arithmetic.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.Records">
            <summary>
            Gets all records
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.OwnerWeight">
            <summary>
            Gets the weight content
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.Item(System.String)">
            <summary>
            Gets or sets a value from
            persistent data
            </summary>
            <param name="name">name</param>
            <returns>value</returns>
        </member>
        <member name="E:PersistantModel.Arithmetic.Fetch">
            <summary>
            Event to fetch all data into
            a unique list of unique records
            </summary>
        </member>
        <member name="E:PersistantModel.Arithmetic.Unfetch">
            <summary>
            Event to unfetch all data into
            a unique list of unique records
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.IsMultipleOperator">
            <summary>
            Gets multiple switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.InnerOperand">
            <summary>
            Gets the inner operand
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.LeftOperand">
            <summary>
            Gets the left operand
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.RightOperand">
            <summary>
            Gets the right operand
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.IsCalculable">
            <summary>
            Gets true if equation is calculable
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.SelectUnknownTerms">
            <summary>
            Gets all unknown terms
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.UnknownTerms">
            <summary>
            Gets all unknown terms
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.SelectCoefficients">
            <summary>
            Gets all coefficients
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.Coefficients">
            <summary>
            Gets all coefficients
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.Constants">
            <summary>
            Gets all constants
            </summary>
        </member>
        <member name="P:PersistantModel.Arithmetic.Equation">
            <summary>
            Gets equation
            </summary>
        </member>
        <member name="M:PersistantModel.Arithmetic.OnFetch(PersistantModel.RecordZone{PersistantModel.Weight})">
            <summary>
            Raise the event fetch
            </summary>
            <param name="records">records</param>
        </member>
        <member name="M:PersistantModel.Arithmetic.OnUnfetch(PersistantModel.RecordZone{PersistantModel.Weight})">
            <summary>
            Raise the event unfetch
            </summary>
            <param name="records">records</param>
        </member>
        <member name="M:PersistantModel.Arithmetic.Set(System.String,System.Object)">
            <summary>
            Sets a value into the dictionary
            </summary>
            <param name="name">name of the field</param>
            <param name="value">value of field</param>
        </member>
        <member name="M:PersistantModel.Arithmetic.Get(System.String,System.Object)">
            <summary>
            Gets a value from the dictionary
            </summary>
            <param name="name">name of the field</param>
            <param name="init">default value</param>
            <returns>value</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.EnsureSign(Interfaces.IArithmetic)">
            <summary>
            Verify when a positive equation
            may contains multiple inner positive or negative
            equation
            </summary>
            <param name="e">equation to test</param>
            <returns>correct equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.EnsureInverse(Interfaces.IArithmetic)">
            <summary>
            Verify when an inverse equation
            may contains multiple inner inverse
            equation
            </summary>
            <param name="e">equation to test</param>
            <returns>correct equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.EnsureSum(Interfaces.IArithmetic,System.Int32)">
            <summary>
            Verify when an equation
            may contains multiple inner add or sub equations
            </summary>
            <param name="e">equation to test</param>
            <param name="direction">sommation or difference</param>
            <returns>correct equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.EnsureProduct(Interfaces.IArithmetic,System.Int32)">
            <summary>
            Verify when an equation
            may contains multiple inner multiplication or division
            equation
            </summary>
            <param name="e">equation to test</param>
            <param name="direction">sommation or difference</param>
            <returns>correct equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="M:PersistantModel.Arithmetic.MakeTransform">
            <summary>
            Transforms an addition into a multiplication
            </summary>
            <returns>a list of possibles equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Compute(System.Boolean)">
            <summary>
            When an equation can be calculable then
            the result is a number else, it's an arithmetic expression
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>result</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.MakeUnique(PersistantModel.Arithmetic)">
            <summary>
            Generates a new arithmetic object
            that's handle by a unique record zone
            This is a protected virtual method
            to be used by inherited classes
            </summary>
        </member>
        <member name="M:PersistantModel.Arithmetic.Clone">
            <summary>
            Clone this arithmetic object
            </summary>
            <returns>new arithmetic object</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.ToString">
            <summary>
            Transforms equation object into a string representation
            </summary>
            <returns>string representation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.MakeUnique">
            <summary>
            Generates a new arithmetic object
            that's handle by a unique record zone
            </summary>
            <returns>arithmetic object</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Let(System.String,System.Double)">
            <summary>
            Let a letter as a value
            given a letter and its value
            </summary>
            <param name="letter">letter value</param>
            <param name="value">numeric value</param>
        </member>
        <member name="M:PersistantModel.Arithmetic.Let(System.String,Interfaces.IArithmetic)">
            <summary>
            Let a letter as an equation
            given a letter and its equation
            </summary>
            <param name="letter">letter value</param>
            <param name="e">equation object</param>
        </member>
        <member name="M:PersistantModel.Arithmetic.AsRepresented(System.String)">
            <summary>
            String representation of the algebraic equation
            </summary>
            <param name="type">type of representation; string or tex</param>
            <returns>string text</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Calculate(System.Boolean)">
            <summary>
            Calculate the result of this equation
            terms that are valued are operated with its numeric value
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>string representation number or algebraic</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Transform">
            <summary>
            Transform the current equation to an
            another equation
            </summary>
            <returns>transformed equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Factorize">
            <summary>
            Factorization of an equation
            works only on a current equation as an addition
            </summary>
            <returns>factorized equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Develop">
            <summary>
            Develop equation
            works only on a current equation as a product
            </summary>
            <returns>developed equation</returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.Equals(PersistantModel.Arithmetic,PersistantModel.Arithmetic)">
            <summary>
            Compare two object
            </summary>
            <param name="x">object left</param>
            <param name="y">object right</param>
            <returns></returns>
        </member>
        <member name="M:PersistantModel.Arithmetic.GetHashCode(PersistantModel.Arithmetic)">
            <summary>
            Hash code of this object
            replacement with the weight hash code
            </summary>
            <param name="obj">obj</param>
            <returns>hash code</returns>
        </member>
        <member name="T:PersistantModel.Coefficient">
            <summary>
            Classe contenant le nom, la valeur numérique
            ou une équation d'un coefficient
            </summary>
        </member>
        <member name="M:PersistantModel.Coefficient.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:PersistantModel.Coefficient.#ctor(System.String,System.Double)">
            <summary>
            Constructor for a coefficient
            given a name
            given a double precision numeric value
            </summary>
            <param name="letter">letter of coefficient</param>
            <param name="value">value behind this letter</param>
        </member>
        <member name="M:PersistantModel.Coefficient.#ctor(System.String)">
            <summary>
            Constructor for a coefficient
            given a name
            with value as 0.0
            </summary>
            <param name="letter">letter of coefficient</param>
        </member>
        <member name="P:PersistantModel.Coefficient.Name">
            <summary>
            Gets the name of this coefficient
            </summary>
        </member>
        <member name="P:PersistantModel.Coefficient.Interfaces#IVariable#Value">
            <summary>
            Gets the value of this coefficient
            </summary>
        </member>
        <member name="P:PersistantModel.Coefficient.Value">
            <summary>
            Gets or sets the value of this coefficient
            </summary>
        </member>
        <member name="P:PersistantModel.Coefficient.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Coefficient.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Coefficient.IsMultipleOperator">
            <summary>
            Gets multiple switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Coefficient.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="M:PersistantModel.Coefficient.Compute(System.Boolean)">
            <summary>
            When an equation can be calculable then
            the result is a number else, it's an arithmetic expression
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>result</returns>
        </member>
        <member name="M:PersistantModel.Coefficient.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.Coefficient.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.NumericValue">
            <summary>
            Classe stockant une valeur numérique
            </summary>
        </member>
        <member name="M:PersistantModel.NumericValue.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.NumericValue.#ctor(System.Double)">
            <summary>
            Constructor for a double precision number
            </summary>
            <param name="d">number</param>
        </member>
        <member name="P:PersistantModel.NumericValue.Value">
            <summary>
            Gets or sets the numeric value
            </summary>
        </member>
        <member name="P:PersistantModel.NumericValue.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.NumericValue.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.NumericValue.IsMultipleOperator">
            <summary>
            Gets multiple switch test
            </summary>
        </member>
        <member name="P:PersistantModel.NumericValue.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="M:PersistantModel.NumericValue.Compute(System.Boolean)">
            <summary>
            When an equation can be calculable then
            the result is a number else, it's an arithmetic expression
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>result</returns>
        </member>
        <member name="M:PersistantModel.NumericValue.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.NumericValue.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.PersistentDataObject">
            <summary>
            Classe contenant la séquence
            de sérialisation/déserialisation
            </summary>
        </member>
        <member name="F:PersistantModel.PersistentDataObject.dict">
            <summary>
            Field to store data information to serialize
            </summary>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="P:PersistantModel.PersistentDataObject.Data">
            <summary>
            Data to be used
            </summary>
        </member>
        <member name="P:PersistantModel.PersistentDataObject.Keys">
            <summary>
            Gets all direct keys
            </summary>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.Exists(System.String)">
            <summary>
            Test if a key exists
            </summary>
            <param name="name">key name</param>
            <returns>true if exists</returns>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.Set(System.String,System.Object)">
            <summary>
            Sets a value into the dictionary
            </summary>
            <param name="name">name of the field</param>
            <param name="value">value of field</param>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.Get(System.String,System.Object)">
            <summary>
            Gets a value from the dictionary
            </summary>
            <param name="name">name of the field</param>
            <param name="init">default value</param>
            <returns>value</returns>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.Remove(System.String)">
            <summary>
            Remove a key
            </summary>
            <param name="name">key name</param>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.Load(System.IO.FileInfo,PersistantModel.PersistentDataObject@)">
            <summary>
            Lecture d'un document
            </summary>
            <param name="file">information de fichier</param>
            <param name="result">objet obtenu</param>
            <returns>true if success</returns>
        </member>
        <member name="M:PersistantModel.PersistentDataObject.Save(System.IO.FileInfo,PersistantModel.PersistentDataObject)">
            <summary>
            Sauvegarde d'un document
            </summary>
            <param name="file">information de fichier</param>
            <param name="data">objet à sérialiser</param>
            <returns>true if success</returns>
        </member>
        <member name="T:PersistantModel.Product">
            <summary>
            Product of multiple terms
            </summary>
        </member>
        <member name="M:PersistantModel.Product.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:PersistantModel.Product.#ctor(Interfaces.IArithmetic[])">
            <summary>
            Constructor with a input list
            </summary>
            <param name="inputs">input list</param>
        </member>
        <member name="P:PersistantModel.Product.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.Product.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Product.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Product.IsMultipleOperator">
            <summary>
            Gets multiple switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Product.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="P:PersistantModel.Product.Items">
            <summary>
            Gets the enumeration of elements by sommation
            </summary>
        </member>
        <member name="P:PersistantModel.Product.List">
            <summary>
            Gets the list source
            </summary>
        </member>
        <member name="M:PersistantModel.Product.IntermediateTransition(PersistantModel.Product)">
            <summary>
            intermediate transition
            </summary>
            <param name="current">current sum</param>
            <returns>a lesser sum</returns>
        </member>
        <member name="M:PersistantModel.Product.Transition">
            <summary>
            Make a product to a
            tree of multiplication
            </summary>
            <returns>a structured addition</returns>
        </member>
        <member name="M:PersistantModel.Product.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Product.ToString">
            <summary>
            Transforms equation object into a string representation
            </summary>
            <returns>string representation</returns>
        </member>
        <member name="M:PersistantModel.Product.Compute(System.Boolean)">
            <summary>
            When an equation can be calculable then
            the result is a number else, it's an arithmetic expression
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>result</returns>
        </member>
        <member name="M:PersistantModel.Product.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.Product.Add(Interfaces.IArithmetic)">
            <summary>
            Add a multiplication to the product
            </summary>
            <param name="a">element to add</param>
        </member>
        <member name="M:PersistantModel.Product.Replace(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Replace an element to an another
            </summary>
            <param name="old">old element</param>
            <param name="n">new element</param>
        </member>
        <member name="M:PersistantModel.Product.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Sum">
            <summary>
            Sommation of multiple terms
            </summary>
        </member>
        <member name="M:PersistantModel.Sum.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:PersistantModel.Sum.#ctor(Interfaces.IArithmetic[])">
            <summary>
            Constructor with a input list
            </summary>
            <param name="inputs">input list</param>
        </member>
        <member name="P:PersistantModel.Sum.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.Sum.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Sum.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Sum.IsMultipleOperator">
            <summary>
            Gets multiple switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Sum.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="P:PersistantModel.Sum.Items">
            <summary>
            Gets the enumeration of elements by sommation
            </summary>
        </member>
        <member name="P:PersistantModel.Sum.List">
            <summary>
            Gets the list source
            </summary>
        </member>
        <member name="M:PersistantModel.Sum.IntermediateTransition(PersistantModel.Sum)">
            <summary>
            intermediate transition
            </summary>
            <param name="current">current sum</param>
            <returns>a lesser sum</returns>
        </member>
        <member name="M:PersistantModel.Sum.Transition">
            <summary>
            Make a sum to a
            tree of addition
            </summary>
            <returns>a structured addition</returns>
        </member>
        <member name="M:PersistantModel.Sum.Add(Interfaces.IArithmetic)">
            <summary>
            Add an addition to the sum
            </summary>
            <param name="a">element to add</param>
        </member>
        <member name="M:PersistantModel.Sum.Replace(Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Replace an element to an another
            </summary>
            <param name="old">old element</param>
            <param name="n">new element</param>
        </member>
        <member name="M:PersistantModel.Sum.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="M:PersistantModel.Sum.ToString">
            <summary>
            Transforms equation object into a string representation
            </summary>
            <returns>string representation</returns>
        </member>
        <member name="M:PersistantModel.Sum.Compute(System.Boolean)">
            <summary>
            When an equation can be calculable then
            the result is a number else, it's an arithmetic expression
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>result</returns>
        </member>
        <member name="M:PersistantModel.Sum.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.Sum.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Term">
            <summary>
            Classe stockant un terme
            </summary>
        </member>
        <member name="M:PersistantModel.Term.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.Term.#ctor(System.Double,System.String,System.String)">
            <summary>
            Constructor for a simple term
            </summary>
            <param name="constant">store a constant value</param>
            <param name="letter">store a coefficient</param>
            <param name="unknown">store an unknown term</param>
        </member>
        <member name="M:PersistantModel.Term.#ctor(Interfaces.IArithmetic,Interfaces.IArithmetic,Interfaces.IArithmetic)">
            <summary>
            Constructor for a term
            </summary>
            <param name="c">constant equation</param>
            <param name="s">coefficient equation</param>
            <param name="u">unknown term equation</param>
        </member>
        <member name="P:PersistantModel.Term.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.Term.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Term.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.Term.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="P:PersistantModel.Term.Constant">
            <summary>
            Gets the constant element
            </summary>
        </member>
        <member name="P:PersistantModel.Term.Coefficient">
            <summary>
            Gets the coefficient element
            </summary>
        </member>
        <member name="P:PersistantModel.Term.Unknown">
            <summary>
            Gets the unknown element
            </summary>
        </member>
        <member name="M:PersistantModel.Term.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.UnknownTerm">
            <summary>
            Terme inconnu
            </summary>
        </member>
        <member name="M:PersistantModel.UnknownTerm.#ctor">
            <summary>
            Default constructor
            Empty data
            </summary>
        </member>
        <member name="M:PersistantModel.UnknownTerm.#ctor(System.String)">
            <summary>
            Constructor
            given a letter name to
            identify unknown term
            </summary>
            <param name="letter">letter</param>
        </member>
        <member name="M:PersistantModel.UnknownTerm.#ctor(System.String,Interfaces.IArithmetic)">
            <summary>
            Constructor
            given a letter name to
            identify unknown term
            given its equation
            </summary>
            <param name="letter">ketter</param>
            <param name="eq">equation</param>
        </member>
        <member name="P:PersistantModel.UnknownTerm.Name">
            <summary>
            Gets the name of this unknown term
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.Interfaces#IVariable#Value">
            <summary>
            Gets the computed value of this unknown term
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.Value">
            <summary>
            Gets the computed value of this unknown term
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.Content">
            <summary>
            Gets or sets the underlying equation
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.Operator">
            <summary>
            Gets the operator ID
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.IsBinaryOperator">
            <summary>
            Gets binary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.IsUnaryOperator">
            <summary>
            Gets unary switch test
            </summary>
        </member>
        <member name="P:PersistantModel.UnknownTerm.IsNotOperator">
            <summary>
            Gets true if it's not an operator
            </summary>
        </member>
        <member name="M:PersistantModel.UnknownTerm.Compute(System.Boolean)">
            <summary>
            When an equation can be calculable then
            the result is a number else, it's an arithmetic expression
            </summary>
            <param name="clean">true if calculate again</param>
            <returns>result</returns>
        </member>
        <member name="M:PersistantModel.UnknownTerm.ComputeOwnerWeight">
            <summary>
            Computes the unique weight
            for this object
            </summary>
            <returns>weight</returns>
        </member>
        <member name="M:PersistantModel.UnknownTerm.Create">
            <summary>
            Create a new arithmetic class
            </summary>
        </member>
        <member name="T:PersistantModel.Verify">
            <summary>
            Verify the validity of an equal
            formula
            </summary>
        </member>
        <member name="F:PersistantModel.Verify.equalOp">
            <summary>
            Equal operation
            </summary>
        </member>
        <member name="M:PersistantModel.Verify.#ctor(PersistantModel.Equal)">
            <summary>
            Construct with an equal term
            </summary>
            <param name="e">equal term</param>
        </member>
        <member name="P:PersistantModel.Verify.IsCalculable">
            <summary>
            Test if calculable
            </summary>
        </member>
        <member name="P:PersistantModel.Verify.Variables">
            <summary>
            Gets all variables
            </summary>
        </member>
        <member name="P:PersistantModel.Verify.Elements">
            <summary>
            Gets all records
            </summary>
        </member>
        <member name="M:PersistantModel.Verify.IsValid">
            <summary>
            
            </summary>
            <returns>true if valid</returns>
        </member>
        <member name="M:PersistantModel.Verify.ToTex">
            <summary>
            Transforms equation object into a tex representation
            </summary>
            <returns>tex representation</returns>
        </member>
        <member name="T:PersistantModel.Weight">
            <summary>
            Class to handle bit values
            to identify an equation uniquely
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.ConstantValueType">
            <summary>
            Value type for a constant
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.CoefficientValueType">
            <summary>
            Value type for a coefficient
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.UnknownTermValueType">
            <summary>
            Value type for an unknown term
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.StringValueType">
            <summary>
            Value type for a string
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.DoubleValueType">
            <summary>
            Value type for a double value
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.BinaryOperatorValueType">
            <summary>
            Value type for a binary operator
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.UnaryOperatorValueType">
            <summary>
            Value type for a unary operator
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.MultipleOperationValueType">
            <summary>
            Value type for a multiple operator
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.typeValueName">
            <summary>
            Index name of value type of this weight
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.arithmeticOperatorName">
            <summary>
            Index name for operator or function
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.valueName">
            <summary>
            Index name for specific data support
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.hashCodeName">
            <summary>
            Index value for hash code
            </summary>
        </member>
        <member name="F:PersistantModel.Weight.ownerObject">
            <summary>
            The current object that's correspond to itself
            </summary>
        </member>
        <member name="M:PersistantModel.Weight.#ctor(System.Byte,System.Char,System.Object,Interfaces.IArithmetic)">
            <summary>
            Compute a weight value
            as a computed hash integer
            </summary>
            <param name="type">value type</param>
            <param name="op">operator or function</param>
            <param name="value">value</param>
            <param name="owner">owner object</param>
        </member>
        <member name="M:PersistantModel.Weight.#ctor(System.Byte,System.Object,Interfaces.IArithmetic)">
            <summary>
            Compute a weight value
            as a computed hash integer
            </summary>
            <param name="type">value type</param>
            <param name="value">value</param>
            <param name="owner">owner object</param>
        </member>
        <member name="P:PersistantModel.Weight.OwnerObject">
            <summary>
            Gets the recorded object
            </summary>
        </member>
        <member name="P:PersistantModel.Weight.HashCode">
            <summary>
            Gets the hash code number
            </summary>
        </member>
        <member name="P:PersistantModel.Weight.Item(System.String)">
            <summary>
            Gets or sets a value from
            persistent data
            </summary>
            <param name="name">name</param>
            <returns>value</returns>
        </member>
        <member name="M:PersistantModel.Weight.Owner_Fetch(System.Object,System.EventArgs)">
            <summary>
            Activate record zone
            </summary>
            <param name="sender">origin</param>
            <param name="e">args</param>
        </member>
        <member name="M:PersistantModel.Weight.Owner_Unfetch(System.Object,System.EventArgs)">
            <summary>
            Deactivate record zone
            </summary>
            <param name="sender">origin</param>
            <param name="e">args</param>
        </member>
        <member name="M:PersistantModel.Weight.Construct(System.Byte,System.Char,System.Object,Interfaces.IArithmetic)">
            <summary>
            Construction of elements
            with a dynamic element (not working in constructor's function)
            </summary>
            <param name="type">value type</param>
            <param name="op">operator</param>
            <param name="value">value</param>
            <param name="owner">owner object</param>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.NumericValue)">
            <summary>
            Computes a weight from a numeric value
            </summary>
            <param name="nv">numeric value object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.Coefficient)">
            <summary>
            Computes a weight from a coefficient object
            </summary>
            <param name="c">coefficient object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.UnknownTerm)">
            <summary>
            Computes a weight from an unknown term
            </summary>
            <param name="ut">unknown term object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.BinaryOperation)">
            <summary>
            Computes a weight from a binary operator
            </summary>
            <param name="op">binary term object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.UnaryOperation)">
            <summary>
            Computes a weight from a unary operator
            </summary>
            <param name="op">unary term object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.Sum)">
            <summary>
            Computes a weight from a multiple sum
            </summary>
            <param name="op">sum equation object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.ComputeWeight(PersistantModel.Product)">
            <summary>
            Computes a weight from a multiple sum
            </summary>
            <param name="op">product equation object</param>
            <returns>weight of this object</returns>
        </member>
        <member name="M:PersistantModel.Weight.op_Equality(PersistantModel.Weight,PersistantModel.Weight)">
            <summary>
            Equality Operator
            </summary>
            <param name="x">weight left</param>
            <param name="y">weight right</param>
            <returns>true if equals</returns>
        </member>
        <member name="M:PersistantModel.Weight.op_Inequality(PersistantModel.Weight,PersistantModel.Weight)">
            <summary>
            Different Operator
            </summary>
            <param name="x">weight left</param>
            <param name="y">weight right</param>
            <returns>true if at least different</returns>
        </member>
        <member name="M:PersistantModel.Weight.Equals(System.Object)">
            <summary>
            Equals overriden method
            </summary>
            <param name="obj">obj to compare</param>
            <returns>true or false</returns>
        </member>
        <member name="M:PersistantModel.Weight.GetHashCode">
            <summary>
            Get hash code
            </summary>
            <returns>hash code</returns>
        </member>
        <member name="M:PersistantModel.Weight.Equals(PersistantModel.Weight,PersistantModel.Weight)">
            <summary>
            Equals two weights
            </summary>
            <param name="x">weight left</param>
            <param name="y">weight right</param>
            <returns>true if equals false elsewhere</returns>
        </member>
        <member name="M:PersistantModel.Weight.GetHashCode(PersistantModel.Weight)">
            <summary>
            Get hash Code from obj
            </summary>
            <param name="obj">weight</param>
            <returns>prior hash code</returns>
        </member>
        <member name="M:PersistantModel.Weight.ToString">
            <summary>
            Obtain the equation function as string representation
            </summary>
            <returns></returns>
        </member>
    </members>
</doc>
